#ifndef __PROBLEME_H__
#define  __PROBLEME_H__

#include "pb.h"


/**  Fonction  initProbleme
 *   Crée et initialise une instance de problème à partir d'un fichier texte.
 *
 *   Paramètre:
 *              char *nomFichierDescriptif  : le nom du fichier à lire.
 * 
 *   Retourne:
 *              Probleme * : un pointeur sur le nouveau problème
 *
 *              NULL : si la lecture échoue.
 *
 *
 */


Probleme *initProbleme(char *nomFichierRescriptif);


/**  Procédure imprimerEnonceProbleme
 *   Imprime sur le fichier de sortie l'enoncé du problème
 *   Si le fichier de sortie n'a pas été défini l'impression a lieu sur stdout


 *   Paramètre:
 *              Probleme *p : le problème à traiter.
 * 
 *
 */


void imprimerEnonceProbleme(Probleme *p);



/**  Fonction  premierEtat
 *   Calcule dans le contexte du problème donné l'état initial de la recherche par énumération
 *
 *   Paramètre:
 *              Probleme *p : le contexte à traiter
 * 
 *   Retourne:
 *              Etat * : le premier etat recherché
 *
 */



Etat *premierEtat(Probleme *p, char*);




/**  Fonction  estSolution 
 *   Teste si un Etat e est une solution du Probleme p 
 *
 *   Paramètres:
 *              Probleme *p : le problème considéré
 *
 *              Etat *e :   l'état qui une solution potentielle.
 * 
 *   Retourne:
 *              1: si l'Etat e est une solution du Probleme p
 *              0: sinon.
 */


int estSolution(Probleme *p, Etat *e) ;



/**  Fonction  estEchec
 *   Teste si  une solution potentielle du Probleme p  peut être construite à partir d'un Etat e. 
 *
 *   Paramètres:
 *              Probleme *p : le problème considéré
 *
 *              Etat *e :   l'état considéré
 * 
 *   Retourne:
 *              1: si aucune solution du Probleme p ne peut être construite à partir de l'Etat e.
 *              0: sinon. 
 */
 


int estEchec( Probleme *p, Etat *e);



/**  Fonction  etatSuivant
 *   Produit une suite "exhaustive" minimale d'extensions de l'état e  dans le contexte du problème p.
 *   
 *   Une état e' est une extension d'un état e si e' est déduit de e en ajoutant une ou plusieurs condition(s) supplémentaires.  
 *
 *   Une suite d'extensions états (e1, e2, .. eN) d'un état e est dite "exhaustive" si extension de l'état e est:
 *             1) Soit un des états e1, e2, .. en
 *             2) Soit une extension de l'un de ces états
 *  
 *
 *   Une suite exhaustive s=(e1, e2, .. eN) d'extensions d'un état e est dite minimale 
 *   si toute s' obtenue à partir de s en retirant l'un quelconque des états e1, e2, ...  eN n'est plus exhaustive. 
 *
 *
 *    Dans le contexte d'un problème p un état e admet en général plusieurs suites exhaustives minimales d'extensions.
 *    Le choix d'une de ces suites correspond donc à un choix d'une stratégie d'énumération qui est implémenté dans la fonction.  
 *
 * 
 *    En outre, l'ordre des états e1, e2, ...  eN  constitue un autre choix stratégique qui peut être important lors de la recherche d'une seule solution
 *
 *
 *    Paramètres:
 *
 *              Probleme *p :  Le problème qui sert de contexte
 *          
 *              Etat *e : L 'Etat dont on veut connaître les extensions possibles
 * 
 *    Retourne:
 *              Etat * : La première extension de l'état e.
 *
 *    Pour obtenir toutes les extensions d' un etat e dans le contexte d'un problème p, il faut procéder de la manière suivante:
 *           1) Appeler etatSuivant(p, e) --> e1
 *
 *           2) Appeler plusieurs fois etatSuivant(p, NULL) qui renvoie  successivement  les états e2, e3, .. eN
 *    
 *           3) Un appel supplémentaire de la forme etatSuivant(p, NULL) renvoie NULL pour indiquer que toute la suite des extensions de e a été explorée
.* 
 *
 *
 */




Etat *etatSuivant(Probleme *p,  Etat  *e) ;





/**  Prccédure imprimerEtat
 *   Imprime sur le fichier de sortie ne description de l'Etat e.
 *   Si le fichier de sortie n'a pas été défini l'impression a lieu sur stdout
 *
 *
 *   Paramètre:
 *              Etat *e : l'Etat à décrire.
 * 
 *
 */




void imprimerEtat( Probleme *p, Etat *e);



/**  Procédure  terminerProbleme
 *   Cette procédure effectue deux actions
 *
 *          1) Elle imprime sur le fichier de sortie (ou sur stdout) un compte-rendu de la résolution
 *
 *          2)  Elle libére la mémoire occupée par le problème
 *
 *
 *   Paramètres:
 *             Probleme *p : Le problème  à traiter
 *
 *             int impression : des directives d'impression du compte-rendu.
 *                         0: ne rien imprimer
 *                         1: imprimer le compte-rendu
 *             
 *             char *infos  : Des informations complémentaires fournies par le programme d'appel.
 *                            Ces informations peuvent être utilisées dans le compte-rendu.
 *
 *
 */



void terminerProbleme( Probleme *p, int impression, char *infos ) ;




#endif 
